home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 24 / Mac Magazin and MacEasy Magazine CD - Issue 24.iso / System / Icons & Texturen / Paper Paster 1.0 / Paper Paster Source Code / WallPaperConvert.c < prev   
Text File  |  1993-03-25  |  12KB  |  671 lines
  1. // -----------------------------------------------------------------------
  2. // -- WallPaperConvert.c, convert a Wallpaper file to a 'ppat' resource
  3. // -----------------------------------------------------------------------
  4.  
  5.  
  6. // -----------------------------------------------------------------------
  7. // -- #include files
  8.  
  9.  
  10. // -----------------------------------------------------------------------
  11. // -- #defines for WallPaperConvert.c
  12.  
  13. #define    VERSION_SUPPORTED        2
  14.  
  15. #define    PIX_DEPTH_OFFSET        10
  16. #define    NUM_COLORS_OFFSET        11
  17. #define    COLOR_TABLE_OFFSET        12
  18.  
  19.  
  20. // -----------------------------------------------------------------------
  21. // -- Typedef's for WallPaperConvert.c
  22.  
  23. typedef    struct    ppatRes
  24.     {
  25.  
  26. // -- The header...
  27.  
  28.     int        patType;
  29.     long    pixMapOffset;
  30.     long    pixDataOffset;
  31.     long    patXData;
  32.     int        patXValid;
  33.     long    patXMap;
  34.     Pattern    pat1Data;
  35.  
  36. // -- The pixMap...
  37.  
  38.     long    baseAddr;
  39.     int        rowBytes;
  40.     Rect    bounds;
  41.     int        pmVersion;
  42.     int        packType;
  43.     long    packSize;
  44.     long    hRes;
  45.     long    vRes;
  46.     int        pixelType;
  47.     int        pixelSize;
  48.     int        cmpCount;
  49.     int        cmpSize;
  50.     long    planeBytes;
  51.     long    pmTable;
  52.     long    pmReserved;
  53.     } ppatRes, *ppatResPtr, **ppatResHandle;
  54.     
  55.  
  56. // -----------------------------------------------------------------------
  57. // -- Function prototypes
  58.  
  59. PixPatHandle    ResToPixPat(Handle ppatHandle);
  60.  
  61. Handle            ConvertWallPaper(Handle rawData);
  62.  
  63. Boolean            VersionCheck(Handle rawData);
  64.  
  65. Handle            CreateHeader(Handle rawData);
  66.  
  67. Boolean            AppendPixelData(Handle ppatHeader, Handle rawData);
  68.  
  69. Boolean            AppendColorTable(Handle ppatHeader, Handle rawData);
  70.  
  71.  
  72. // -----------------------------------------------------------------------
  73. // -- Convert a 'ppat' resource to a PixPatHandle
  74.  
  75. PixPatHandle    ResToPixPat(Handle ppatHandle)
  76. {
  77. PixPatHandle    result = nil;
  78. PixMapHandle    pMap;
  79. Handle            pData;
  80. CTabHandle        cTab;
  81. long            dataSize, cTabSize;
  82. int                err;
  83.  
  84. // -- Figure out how much space is needed for the color table & pixel data
  85.  
  86. asm
  87.     {
  88.     move.l    ppatHandle, A0
  89.     move.l    (A0), A0
  90.  
  91. // -- First, get the pixel data size
  92.  
  93.     clr.l    D0
  94.     move.w    OFFSET(ppatRes, rowBytes)(A0), D0
  95.     bclr    #15, D0
  96.     bclr    #14, D0
  97.     bclr    #13, D0
  98.     
  99.     clr.l    D1
  100.     move.w    OFFSET(ppatRes, bounds.bottom)(A0), D1
  101.     mulu    D0, D1
  102.     move.l    D1, dataSize
  103.  
  104. // -- Now get the size of the color table
  105.  
  106.     move.l    OFFSET(ppatRes, pmTable)(A0), D0
  107.     add.l    D0, A0
  108.     move.l    (A0)+, D0
  109.     move.w    (A0)+, D0
  110.     clr.l    D0
  111.     move.w    (A0)+, D0
  112.     add.w    #1, D0
  113.     mulu    #8, D0
  114.     add.w    #8, D0
  115.     move.l    D0, cTabSize
  116.     }
  117.  
  118. // -- Allocate our PixMapHandle
  119.  
  120. pMap = (PixMapHandle)NewHandle(sizeof(PixMap));
  121. if (pMap != nil)
  122.     {
  123.  
  124. // -- Allocate the pattern data buffer
  125.  
  126.     pData = NewHandle(dataSize);
  127.     if (pMap == nil)
  128.         {
  129.         DisposHandle((Handle)pMap);
  130.         }
  131.     else
  132.         {
  133.  
  134. // -- Allocate our CTabHandle
  135.  
  136.         cTab = (CTabHandle)NewHandle(cTabSize);
  137.         if (cTab == nil)
  138.             {
  139.             DisposHandle((Handle)pMap);
  140.             DisposHandle(pData);
  141.             }
  142.         else
  143.             {
  144.  
  145. // -- Allocate our PixPatHandle
  146.  
  147.             result = (PixPatHandle)NewHandle(sizeof(PixPat));
  148.             if (result == nil)
  149.                 {
  150.                 DisposHandle((Handle)pMap);
  151.                 DisposHandle((Handle)cTab);
  152.                 DisposHandle(pData);
  153.                 }
  154.             else
  155.                 {
  156.  
  157. // -- Fill in our PixPatHandle
  158.  
  159.                 MoveHHi((Handle)result);
  160.                 MoveHHi(ppatHandle);
  161.                 HLock((Handle)result);
  162.                 HLock(ppatHandle);
  163.                 BlockMove(*ppatHandle, *result, sizeof(PixPat));
  164.                 (**result).patMap = pMap;
  165.                 (**result).patData = pData;
  166.                 (**result).patXValid = -1;
  167.  
  168. // -- Now fill out the PixMapHandle
  169.  
  170.                 asm
  171.                     {
  172.                     move.l    ppatHandle, A0
  173.                     move.l    (A0), A0
  174.                     
  175.                     move.l    OFFSET(ppatRes, pixMapOffset)(A0), D0
  176.                     add.l    D0, A0
  177.                     
  178.                     move.l    pMap, A1
  179.                     move.l    (A1), A1
  180.                     
  181.                     move.l    #sizeof(PixMap), D0
  182.                     
  183.                     _BlockMove
  184.                     }
  185.                 
  186.                 (**pMap).baseAddr = (*pData);
  187.                 (**pMap).pmTable = cTab;
  188.  
  189. // -- Set up the pixel data handle
  190.  
  191.                 asm
  192.                     {
  193.                     move.l    ppatHandle, A0
  194.                     move.l    (A0), A0
  195.                     
  196.                     move.l    OFFSET(ppatRes, pixDataOffset)(A0), D0
  197.                     add.l    D0, A0
  198.                     
  199.                     move.l    pData, A1
  200.                     move.l    (A1), A1
  201.                     
  202.                     move.l    dataSize, D0
  203.                     
  204.                     _BlockMove
  205.                     }
  206.  
  207. // -- Set up the color table handle
  208.  
  209.                 asm
  210.                     {
  211.                     move.l    ppatHandle, A0
  212.                     move.l    (A0), A0
  213.                     
  214.                     move.l    OFFSET(ppatRes, pmTable)(A0), D0
  215.                     add.l    D0, A0
  216.                     
  217.                     move.l    cTab, A1
  218.                     move.l    (A1), A1
  219.                     
  220.                     move.l    cTabSize, D0
  221.                     
  222.                     _BlockMove
  223.                     }
  224.  
  225.                 (**cTab).ctSeed = GetCTSeed();
  226.  
  227. // -- Allocate the X structures
  228.  
  229.                 (**result).patXMap = NewHandle(sizeof(PixMap));
  230.                 if ((**result).patXMap == nil)
  231.                     {
  232.                     DisposHandle((Handle)result);
  233.                     DisposHandle((Handle)pMap);
  234.                     DisposHandle((Handle)cTab);
  235.                     DisposHandle(pData);
  236.                     result = nil;
  237.                     }
  238.                 else
  239.                     {
  240.                     (**result).patXData = NewHandle(2);
  241.                     if ((**result).patXData == nil)
  242.                         {
  243.                         DisposHandle((Handle)(**result).patXMap);
  244.                         DisposHandle((Handle)result);
  245.                         DisposHandle((Handle)pMap);
  246.                         DisposHandle((Handle)cTab);
  247.                         DisposHandle(pData);
  248.                         result = nil;
  249.                         }
  250.                     }
  251.  
  252. // -- Clean up
  253.  
  254.                 if (result != nil)
  255.                     HUnlock((Handle)result);
  256.                 HUnlock(ppatHandle);
  257.  
  258.                 }
  259.             }
  260.         }
  261.     }
  262.     
  263. DisposHandle(ppatHandle);
  264.  
  265. return result;
  266. }    // -- ResToPixPat
  267.  
  268.  
  269. // -----------------------------------------------------------------------
  270. // -- Convert a wallpaper file to a 'ppat' resource
  271.  
  272. Handle ConvertWallPaper(Handle rawData)
  273. {
  274. Handle    result = nil;
  275. Handle    ppatHeader;
  276.  
  277. if (rawData != nil)
  278.     {
  279.  
  280. // -- Make sure this is a Wallpaper version we can handle
  281.  
  282.     if (VersionCheck(rawData))
  283.         {
  284.  
  285. // -- Create the 'ppat' header and fill it in
  286.  
  287.         ppatHeader = CreateHeader(rawData);
  288.         if (ppatHeader != nil)
  289.             {
  290.  
  291. // -- Add the pattern's pixel data to the recipe
  292.  
  293.             if (AppendPixelData(ppatHeader, rawData))
  294.                 {
  295.  
  296. // -- Finally, add the color table
  297.  
  298.                 if (AppendColorTable(ppatHeader, rawData))
  299.                     {
  300.  
  301. // -- We've got our converted 'ppat' resource; return it
  302.  
  303.                     result = ppatHeader;
  304.                     }
  305.                 }
  306.             }
  307.         }
  308.  
  309. // -- Get rid of the rawData handle
  310.  
  311.     DisposHandle(rawData);
  312.     }
  313.  
  314. return result;
  315. }    // -- ConvertWallPaper
  316.  
  317.  
  318. // -----------------------------------------------------------------------
  319. // -- Add the pixel information to the 'ppat' resource
  320.  
  321. Boolean    AppendPixelData(Handle ppatHeader, Handle rawData)
  322. {
  323. Boolean    result = true;
  324.  
  325. asm
  326.     {
  327.     move.l    D6, -(SP)
  328.         
  329.     move.l    ppatHeader, A0
  330.     _GetHandleSize
  331.     move.l    D0, -(SP)
  332.     
  333.     move.l    ppatHeader, A0
  334.     move.l    (A0), A1
  335.  
  336. // -- Calculate how much bigger we should make this handle
  337.  
  338.     clr.l    D0
  339.     move.w    OFFSET(ppatRes, rowBytes)(A1), D0
  340.     clr.l    D1
  341.     move.w    OFFSET(ppatRes, bounds.right)(A1), D1
  342.     mulu.w    D1, D0
  343.     move.l    D0, D6
  344.     
  345.     add.l    (SP)+, D0
  346.     
  347.     _SetHandleSize
  348.     tst.w    MemErr
  349.     bne        @memoryError
  350.  
  351. // -- Now blockmove the pixel data in
  352.  
  353.     move.l    rawData, A0
  354.     move.l    (A0), A0
  355.     add.w    #NUM_COLORS_OFFSET, A0
  356.     clr.l    D0
  357.     move.b    (A0)+, D0
  358.     add.w    #1, D0
  359.     mulu.w    #3, D0
  360.     add.w    D0, A0
  361.     add.w    #2, A0
  362.     
  363.     move.l    ppatHeader, A1
  364.     move.l    (A1), A1
  365.     move.l    OFFSET(ppatRes, pixDataOffset)(A1), D0
  366.     add.l    D0, A1
  367.     
  368.     move.l    D6, D0
  369.     
  370.     _BlockMove
  371.     
  372.     bra        @out
  373.     
  374. @memoryError
  375.  
  376.     move.l    ppatHeader, A0
  377.     _DisposHandle
  378.     clr.l    ppatHeader
  379.     move.b    #false, result
  380.     
  381. @out
  382.  
  383.     move.l    (SP)+, D6
  384.     }
  385.  
  386. return result;
  387. }    // -- AppendPixelData
  388.  
  389.  
  390. // -----------------------------------------------------------------------
  391. // -- Add the color table to the 'ppat' resource
  392.  
  393. Boolean    AppendColorTable(Handle ppatHeader, Handle rawData)
  394. {
  395. Boolean    result = true;
  396.  
  397. asm
  398.     {
  399.     move.l    D6, -(SP)
  400.     
  401.     move.l    ppatHeader, A0
  402.     _GetHandleSize
  403.     move.l    D0, -(SP)
  404.     
  405. // -- figure out how much bigger the 'ppat' needs to be
  406.  
  407.     move.l    rawData, A1
  408.     move.l    (A1), A1
  409.     add.w    #NUM_COLORS_OFFSET, A1
  410.     clr.l    D0
  411.     move.b    (A1), D0
  412.     add.w    #1, D0
  413.     mulu    #8, D0
  414.     add.w    #8, D0
  415.     add.l    (SP)+, D0
  416.  
  417. // -- Make the handle bigger
  418.  
  419.     move.l    ppatHeader, A0
  420.     _SetHandleSize
  421.     tst.w    MemErr
  422.     bne        @memoryError
  423.  
  424. // -- expand the color table
  425.  
  426.     move.l    ppatHeader, A1
  427.     move.l    (A1), A1
  428.     move.l    OFFSET(ppatRes, pmTable)(A1), D0
  429.     add.l    D0, A1
  430.     move.l    #0, (A1)+                    // -- ctSeed
  431.     move.w    #0, (A1)+                    // -- ctFlags
  432.     
  433.     move.l    rawData, A0
  434.     move.l    (A0), A0
  435.     add.w    #NUM_COLORS_OFFSET, A0
  436.     clr.l    D0
  437.     move.b    (A0)+, D0
  438.     move.w    D0, (A1)+                    // -- ctSize
  439.     
  440.     clr.l    D6
  441.     
  442. @colorTableLoop
  443.  
  444.     move.w    D6, (A1)+
  445.     add.w    #1, D6
  446.     
  447. // -- Red
  448.  
  449.     move.b    (A0)+, D1
  450.     move.b    D1, (A1)+
  451.     move.b    D1, (A1)+
  452.     
  453. // -- Green
  454.  
  455.     move.b    (A0)+, D1
  456.     move.b    D1, (A1)+
  457.     move.b    D1, (A1)+
  458.     
  459. // -- Blue
  460.  
  461.     move.b    (A0)+, D1
  462.     move.b    D1, (A1)+
  463.     move.b    D1, (A1)+
  464.     
  465.     dbra    D0, @colorTableLoop
  466.  
  467. // -- Lastly, let 'em know this is a color pixmap
  468.  
  469.     move.l    ppatHeader, A0
  470.     move.l    (A0), A0
  471.     
  472.     add.w    #0x8000, OFFSET(ppatRes, rowBytes)(A0)
  473.      
  474.     bra        @out
  475.     
  476. @memoryError
  477.  
  478.     move.l    ppatHeader, A0
  479.     _DisposHandle
  480.     clr.l    ppatHeader
  481.     move.b    #false, result
  482.     
  483. @out
  484.  
  485.     move.l    (SP)+, D6
  486.     }
  487.  
  488. return result;
  489. }    // -- AppendColorTable
  490.  
  491.  
  492. // -----------------------------------------------------------------------
  493. // -- Create the 'ppat' resource header
  494.  
  495. Handle CreateHeader(Handle rawData)
  496. {
  497. Handle    result = nil;
  498. long    dataOffset, cTabOffset;
  499.  
  500. dataOffset = sizeof(ppatRes);
  501. cTabOffset = sizeof(ppatRes);
  502.  
  503. result = NewHandle(sizeof(ppatRes));
  504. if (result != nil)
  505.     {
  506.  
  507. // -- Fill in the default values of the 'ppat' header
  508.  
  509.     asm
  510.         {
  511.         move.l    D3, -(SP)
  512.         move.l    A2, -(SP)
  513.         
  514. // -- Load in pointers to our data blocks
  515.  
  516.         move.l    result, A0
  517.         move.l    (A0), A0
  518.         
  519.         move.l    rawData, A1
  520.         move.l    (A1), A1
  521.         
  522. // -- Fill out the header information
  523.  
  524.         move.w    #1, (A0)+            // -- full color pattern
  525.         move.l    #28, (A0)+            // -- offset to pixmap record
  526.         move.l    dataOffset, (A0)+    // -- offset to pixel data
  527.         move.l    #0, (A0)+            // -- patXData
  528.         move.w    #-1, (A0)+            // -- patXValid
  529.         move.l    #0, (A0)+            // -- patXMap
  530.         move.l    #0xAA55AA55, (A0)+    // -- b/w pattern        
  531.         move.l    #0xAA55AA55, (A0)+    // -- b/w pattern        
  532.  
  533. // -- Fill out the pixmap information
  534.  
  535.         move.l    #0, (A0)+            // -- baseAddr
  536.  
  537. // -- We have to bypass the variable-length miniature clut to get the rowBytes
  538.  
  539.         move.l    A1, A2
  540.         add.w    #NUM_COLORS_OFFSET, A2
  541.         clr.l    D0
  542.         move.b    (A2)+, D0
  543.         add.w    #1, D0
  544.         mulu.w    #3, D0
  545.         add.w    D0, A2
  546.         move.w    (A2), D0
  547.         move.w    D0, (A0)+            // -- rowBytes
  548.         move.l    D0, D3
  549.         
  550. // -- We have to compute the bounds from the rowBytes and pixelSize
  551.  
  552.         clr.l    D1
  553.         move.b    PIX_DEPTH_OFFSET(A1), D1
  554.  
  555. // -- Is it a 1 bit pixmap?
  556.  
  557.         cmp.w    #1, D1
  558.         bne        @not1
  559.         
  560.         mulu.w    #8, D0
  561.         bra        @gotBounds
  562.  
  563. @not1
  564.  
  565. // -- Is it a 2 bit pixmap?
  566.  
  567.         cmp.w    #2, D1
  568.         bne        @not2
  569.         
  570.         mulu.w    #4, D0
  571.         bra        @gotBounds
  572.  
  573. @not2
  574.  
  575. // -- Is it a 4 bit pixmap?
  576.  
  577.         cmp.w    #4, D1
  578.         bne        @not4
  579.         
  580.         mulu.w    #2, D0
  581.         bra        @gotBounds
  582.  
  583. @not4
  584.  
  585. // -- Is it a 8 bit pixmap?
  586.  
  587.         cmp.w    #8, D1
  588.         bne        @not8
  589.         
  590.         bra        @gotBounds
  591.  
  592. @not8
  593.  
  594. // -- Is it a 16 bit pixmap?
  595.  
  596.         cmp.w    #16, D1
  597.         bne        @not16
  598.         
  599.         divu.w    #2, D0
  600.         bra        @gotBounds
  601.  
  602. @not16
  603.  
  604. // -- Is it a 32 bit pixmap?
  605.  
  606.         cmp.w    #32, D1
  607.         bne        @not32
  608.         
  609.         divu.w    #4, D0
  610.         bra        @gotBounds
  611.  
  612. @not32
  613.  
  614. // -- We should never get here...
  615.  
  616.         _Debugger
  617.     
  618. @gotBounds
  619.  
  620.         move.w    #0, (A0)+            // -- bounds.top
  621.         move.w    #0, (A0)+            // -- bounds.left
  622.         move.w    D0, (A0)+            // -- bounds.bottom
  623.         move.w    D0, (A0)+            // -- bounds.right
  624.         
  625.         move.w    #0, (A0)+            // -- pmVersion
  626.         move.w    #0, (A0)+            // -- packType
  627.         move.l    #0, (A0)+            // -- packSize
  628.         move.l    #0x00480000, (A0)+    // -- hRes
  629.         move.l    #0x00480000, (A0)+    // -- vRes
  630.         move.w    #0, (A0)+            // -- chunky
  631.         move.w    D1, (A0)+            // -- bits per pixel
  632.         move.w    #1, (A0)+            // -- cmpCount
  633.         move.w    D1, (A0)+            // -- cmpSize = bits per pixel
  634.         move.l    #0, (A0)+            // -- planeBytes
  635.  
  636. // -- Add the size of the pixel data to the cTabOffset
  637.  
  638.         mulu.w    D3, D0
  639.         add.l    D0, cTabOffset
  640.         move.l    cTabOffset, (A0)+    // -- Offset to the color table
  641.  
  642.         move.l    #0, (A0)+            // -- pmReserved
  643.  
  644.         move.l    (SP)+, A2
  645.         move.l    (SP)+, D3
  646.         }
  647.     }
  648.  
  649. return result;
  650. }    // -- CreateHeader
  651.  
  652.  
  653. // -----------------------------------------------------------------------
  654. // -- Make sure this is a Wallpaper version we can handle
  655.  
  656. Boolean VersionCheck(Handle rawData)
  657. {
  658. Boolean    versOK;
  659.  
  660. asm
  661.     {
  662.     move.b    #0, D0
  663.     move.l    rawData, A0
  664.     move.l    (A0), A0
  665.     cmp.w    #VERSION_SUPPORTED, (A0)
  666.     seq        D0
  667.     move.b    D0, versOK
  668.     }
  669.  
  670. return versOK;
  671. }    // -- VersionCheck